Implement Logger Module with GrayLogger in NodeJS with TypeScript [Modularized Code]

Every node application needs a logger service. This logger service will be used to log all the information in the node. In this implementation, we will create a Nodejs app with a logger service and this will log all your information. We will be using GrayLogger in TypeScript with Nodejs framework ie. NestJS

In this article, we will implement a LoggerModule by using NestJS and TypeScript. NestJS is a NodeJs framework that is used to build NodeJs server-side applications. NestJs uses TypeScript which helps developers to implement highly scalable and maintainable applications. NestJs built on top of ExpressJs.

Let's Create a NestJS Module for Logger

Here we will create a LoggerModule, in this module we will use an npm module which is graylog2, The graylog2 is an open-source module to write the logs on your server. So let's get started.

First, let's have a look at the directory structure. We will have a directory called LoggerModule in this folder we will have our all the logger module codes and later we will see how we can use this LoggerModule in our other application. 

Directory Structure
LoggerModule/logger.decorator.ts
LoggerModule/logger.module.ts
LoggerModule/logger.providers.ts
LoggerModule/logger.service.ts
LoggerModule/logger.utils.ts

Write the codes

Let's write the codes, I have added the description of the codes in the comments. You can read the comments for more understanding.
LoggerModule/logger.decorator.ts

                    
                                import { Inject } from '@nestjs/common';
                                import { getGrayLoggerToken } from '../logger.utils';
                                import { LoggerModule } from './logger.module';
                    
                                /**
                                * Injects a `LoggerService prefix`
                                * @param prefix Prefix which gets prepended before every log message
                                */
                                export function Logger(prefix = '') {
                                if (!LoggerModule.prefixesForLoggers.includes(prefix)) {
                                    LoggerModule.prefixesForLoggers.push(prefix);
                                }
                                return Inject(getGrayLoggerToken(prefix));
                                }
                    
                            

LoggerModule/logger.module.ts

                    
                                import { DynamicModule, Global } from '@nestjs/common';
                                import { GrayLoggerService } from './logger.service';
                                import { createLoggerProviders } from './logger.providers';
                                /**
                                * Created a LoggerModule
                                */
                    
                                @Global()
                                export class LoggerModule {
                                    static prefixesForLoggers: string[] = new Array<string>();
                    
                                    static forRoot(): DynamicModule {
                                    const prefixedLoggerProviders = createLoggerProviders(
                                        this.prefixesForLoggers,
                                    );
                                    return {
                                        module: LoggerModule,
                                        imports: [],
                                        providers: [GrayLoggerService, ...prefixedLoggerProviders],
                                        exports: [GrayLoggerService, ...prefixedLoggerProviders],
                                    };
                                    }
                                }
                    
                            

LoggerModule/logger.providers.ts

                    
                                import { Provider } from '@nestjs/common';
                                import { GrayLoggerService } from './logger.service';
                                import { getGrayLoggerToken } from './logger.utils';
                    
                                /**
                                * 
                                * @param logger logger service instance
                                * @param prefix a string that identifies the prefix
                                * @returns logger instance
                                */
                                function loggerFactory(logger: GrayLoggerService, prefix: string) {
                                    if (prefix) {
                                        logger.setPrefix(prefix);
                                    }
                                    return logger;
                                }
                    
                    
                                /**
                                * Create a new logger provider
                                * @param prefix a prefix for the logger
                                * @returns an object
                                */
                                function createLoggerProvider(prefix: string): Provider<GrayLoggerService> {
                                    return {
                                        provide: getGrayLoggerToken(prefix),
                                        useFactory: (logger) => loggerFactory(logger, prefix),
                                        inject: [GrayLoggerService],
                                    };
                                }
                    
                                /**
                                * Creates Logger providers for each given prefix
                                */
                                export function createLoggerProviders(
                                prefixes: string[],
                                ): Array<Provider<GrayLoggerService>> {
                                    return prefixes.map((prefix) => createLoggerProvider(prefix));
                                }
                    
                            

LoggerModule/logger.service.ts

                    
                                import { Injectable } from '@nestjs/common';
                                import _ = require('lodash');
                                import graylog2 = require('graylog2');
                                import { getCurrentDateTimeIST, replacer, LOGGER_CONSTANTS } from './logger.utils';
                                
                                @Injectable()
                                export class GrayLoggerService {
                                  private prefix?: string;
                                  private grayLogger: any = new graylog2.graylog({
                                    servers: [
                                      {
                                        host: LOGGER_CONSTANTS.host,
                                        port: LOGGER_CONSTANTS.port,
                                      },
                                    ],
                                  }).on('error', (err) => {
                                    console.log(' GL error ', err);
                                  });
                                
                                  constructor() {
                                  }
                                
                                  private getData = (data: any): Array<any> => {
                                    const [shortMessage, longMessage, extraInfo] = data;
                                    const source = LOGGER_CONSTANTS.appName;
                                    const timestamp = getCurrentDateTimeIST();
                                    const userId = LOGGER_CONSTANTS.userId;
                                    const error = LOGGER_CONSTANTS.userId;
                                    const errorCode = LOGGER_CONSTANTS.errorCode;
                                
                                    const info = {
                                      source,
                                      userId,
                                      timestamp,
                                      error,
                                      errorCode
                                    };
                                    // if only data object if provided
                                    if (_.isPlainObject(shortMessage)) {
                                      return [_.assign({}, shortMessage, info)];
                                    }
                                    
                                    // if a short message and data object is provided
                                    if (_.isPlainObject(longMessage)) {
                                      return [shortMessage, _.assign({}, longMessage, info)];
                                    }
                                
                                    // if short, long message and data object provided
                                    if (_.isPlainObject(extraInfo)) {
                                      return [shortMessage, longMessage, _.assign({}, extraInfo, info)];
                                    }
                                    return [...data, info];
                                  };
                                
                                  private logHandler = (level: string, msg: any, options?: { jsonPayload?: any, isAnyOtherData?: boolean }) => {
                                    try {
                                      const metaData = {
                                        appName: LOGGER_CONSTANTS.appName,
                                        userId: LOGGER_CONSTANTS.userId,
                                        level,
                                        timestamp: getCurrentDateTimeIST(),
                                      };
                                
                                      console.log(JSON.stringify({ msg, ...metaData }));
                                
                                
                                      if (options?.jsonPayload) {
                                        if (options?.isAnyOtherData === true) {
                                          msg = msg + ' ' + JSON.stringify(options.jsonPayload, replacer);
                                        }
                                        else {
                                          msg = msg + ' ' + JSON.stringify(options.jsonPayload);
                                        }
                                      }
                                
                                      if (LOGGER_CONSTANTS.isEnabled) {
                                        const processedData: Array<any> = this.getData([msg]);
                                        this.grayLogger[level](...processedData);
                                      }
                                    } catch (error) {
                                      console.error('Failed to write logs ', error);
                                    }
                                  };
                                
                                  log(message: string, options?: { data?: any, isAnyOtherData?: boolean, prefix?: string }) {
                                    message = options?.prefix ? `[${options?.prefix}] ${message}` : `[Logs] ${message}`;
                                    this.logHandler('info', message, { jsonPayload: options?.data, isAnyOtherData: options?.isAnyOtherData });
                                  }
                                
                                  error(message: string, options?: { data?: any, isAnyOtherData?: boolean, prefix?: string }) {
                                    message = options?.prefix ? `[${options?.prefix}] ${message}` : `[Logs] ${message}`;
                                    this.logHandler('error', message, { jsonPayload: options?.data, isAnyOtherData: options?.isAnyOtherData });
                                  }
                                
                                  warn(message: string, options?: { data?: any, isAnyOtherData?: boolean, prefix?: string }) {
                                    message = options?.prefix ? `[${options?.prefix}] ${message}` : `[Logs] ${message}`;
                                    this.logHandler('warn', message, { jsonPayload: options?.data, isAnyOtherData: options?.isAnyOtherData });
                                  }
                                
                                  debug(message: string, options?: { data?: any, isAnyOtherData?: boolean, prefix?: string }) {
                                    message = options?.prefix ? `[${options?.prefix}] ${message}` : `[Logs] ${message}`;
                                    this.logHandler('debug', message, { jsonPayload: options?.data, isAnyOtherData: options?.isAnyOtherData });
                                  }
                                
                                  info(message: string, options?: { data?: any, isAnyOtherData?: boolean, prefix?: string }) {
                                    message = options?.prefix ? `[${options?.prefix}] ${message}` : `[Logs] ${message}`;
                                    this.logHandler('info', message, { jsonPayload: options?.data, isAnyOtherData: options?.isAnyOtherData });
                                  }
                                
                                  verbose(message: string, options?: { data?: any, isAnyOtherData?: boolean, prefix?: string }) {
                                    message = options?.prefix ? `[${options?.prefix}] ${message}` : `[Logs] ${message}`;
                                    this.logHandler('info', message, { jsonPayload: options?.data, isAnyOtherData: options?.isAnyOtherData });
                                  }
                                
                                  emergency(message: string, prefix?: string) {
                                    message = prefix ? `[${prefix}] ${message}` : `[Logs] ${message}`;
                                    message = this.getTruncateLargeMessage(message);
                                    this.logHandler('emergency', message);
                                  }
                                
                                  alert(message: string, prefix?: string) {
                                    message = prefix ? `[${prefix}] ${message}` : `[Logs] ${message}`;
                                    message = this.getTruncateLargeMessage(message);
                                    this.logHandler('alert', message);
                                  }
                                
                                  critical(message: string, prefix?: string) {
                                    message = prefix ? `[${prefix}] ${message}` : `[Logs] ${message}`;
                                    message = this.getTruncateLargeMessage(message);
                                    this.logHandler('critical', message);
                                  }
                                
                                  /**
                                   * Set the prefix of every log message
                                   *
                                   * @param prefix The prefix which should be prepended before every log message
                                   */
                                  setPrefix(prefix: string) {
                                    this.prefix = prefix;
                                  }
                                
                                  getTruncateLargeMessage(message: string) {
                                    return _.truncate(message, {
                                      length: 100000,
                                      omission: '...',
                                    });
                                  }
                                }            
                    
                            

LoggerModule/logger.utils.ts

                    
                                const TIME_ZONE_ADJUSTMENT_FACTOR = 330 * 60000;
                                const blackListedLogFields = ['emailId', 'number', 'firstName', 'middleName', 'lastName', 'pan',
                                    'nameOnCard', 'title', 'fullName', 'gender', 'dateOfBirth', 'nickName', 'panName', 'emailFirstName',
                                    'emailLastName', 'standardizedEmailId', 'mobileNumber', 'dob', 'pin', 'oldPin', 'newPin', 'password',
                                    'phoneNumber', 'access_token', 'refresh_token', 'Authorization'];
                                
                                
                                export const LOGGER_CONSTANTS = {
                                    host: 'host',
                                    port: 3000,
                                    appName: 'myApp',
                                    userId: 'myUSerID',
                                    error: 'This is error',
                                    errorCode: 'ERROR_CODE',
                                    isEnabled: true
                                }
                                
                                /**
                                 * 
                                 * @param mobileNumber Mobine no to be masked
                                 * @returns masked value
                                 */
                                export const maskMobileNumber = (mobileNumber: string) => {
                                    const regex = /(?<=\d\d)\d(?=\d{3})/g;
                                    return mobileNumber?.replace(regex, '*');
                                };
                                
                                /**
                                 * 
                                 * @param str string that needs to be masked
                                 * @returns masked value
                                 */
                                export const maskString = (str: string) => {
                                    const res = [...str].map((letter, index) => {
                                        return index % 2 ? '*' : letter;
                                    });
                                    return res.join("");
                                };
                                
                                /**
                                 * @param emailId a string to mask
                                 * @returns masked emailID
                                 */
                                export const maskEmailId = (emailId: string) => {
                                    if (emailId) {
                                        const regex = /^(..)(.*)(..@.*)$/;
                                        const maskedId = emailId.replace(
                                            regex,
                                            (_, a, b, c) => a + b.replace(/./g, '*') + c,
                                        );
                                        if (emailId.split('@')[0].length >= 8) {
                                            return maskedId;
                                        } else {
                                            const domainSplit = maskedId.split('@');
                                            const domain = domainSplit[1].split('.');
                                            return (
                                                domainSplit[0] + '@' + '*'.repeat(domain[0].length) + '.' + domain[1]
                                            );
                                        }
                                    }
                                };
                                
                                /**
                                 * Creates the token for a logger with a prefix
                                 * @param prefix The prefix of the logger
                                 */
                                export const getGrayLoggerToken = (prefix = ''): string => `GrayLoggerService${prefix}`;
                            
                                
                                /**
                                 * 
                                 * @returns Sat Feb 11 2023 02:51:34 GMT+0530 (India Standard Time)
                                 */
                                export const getCurrentDateTimeIST = () => {
                                    return new Date(new Date().getTime() + TIME_ZONE_ADJUSTMENT_FACTOR);
                                };
                                
                                /**
                                 * 
                                 * @param key any blackListedLogFields as declared above
                                 * @param value to replace key with given value
                                 * @returns replaced values
                                 */
                                export const replacer = (key, value) => {
                                    if (blackListedLogFields.includes(key)) {
                                        switch (key) {
                                            case 'emailId':
                                                return maskEmailId(value);
                                            case 'number':
                                            case 'mobileNumber':
                                                return maskMobileNumber(value);
                                            default:
                                                return maskString(value);
                                        }
                                    }
                                    return value;
                                };
                    
                    
                            

Let's use this LoggerModule in our Application

app.module.ts

                                    import { Module } from '@nestjs/common';
                                    import { LoggerModule } from './LoggerModule/logger.module';
                                    @Module({
                                        imports: [
                                            LoggerModule.forRoot(),
                                        ],
                                        controllers: [],
                                        providers: []
                                    })
                                    export class AppModule { }
                                    
                                

app.service.ts

                    
                                    import { GrayLoggerService } from "./LoggerModule/logger.service";
                                    import { Injectable } from "@nestjs/common";
                                    
                                    @Injectable()
                                    export class MyService {
                                        constructor(
                                            private logger: GrayLoggerService,
                                        ) { }
                                    
                                        async someFunctions() {
                                            // Do something
                                            const myLogData = {
                                                // some object
                                            }
                                            this.logger.info(`Log my data: ${JSON.stringify(myLogData || {})}`);
                                        };
                                    }
                                                    
                                

---

Conclusion:

In this article, we have learned how to implement a Logger Module in our Node application.
We have implemented the graylog2 with TypeScript.

Related Keywords:

Node.js logging best practices: The essential guide

Send logs to Graylog

Central logging in NodeJs and NestJS with Graylog2

Configuring Logging in NodeJs with NestJS

Centralized logging using Graylog

Implement Logger Module with GrayLogger